# abs(x) 返回数字的绝对值
print(abs(-45))
print(abs(110))
print(abs(99.9))

# all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。
print(all(['a', 'b', 'c', 'd', 'a', 'c']))
print(all(['', 'a', 'b', 'c']))

# any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
print(any(['a', 'b', ' ', 'c']))
print(any([0, '', 'a', False]))

# bin() int转换为2进制
print(bin(45))
print(bin(-10))

# bool() 类型的判断
print(bool(1))
print(bool(0))
print(bool('this'))

# bytearray  返回一个新的字节数组
print(bytearray())
print(bytearray('测试', 'utf-8'))

# callable 检查一个函数 是否可以被调用
print(callable(1))
print(callable('this is test'))


def add():
    print('this test callable')


print(callable(add))

# chr 返回 数字对应的字符
print (chr(97), chr(49))


# classmethod 装饰器 返回类方法
class A():
    bar = 1

    def func1(self):
        print('func1')

    @classmethod
    def func2(cls):
        print('func2')
        print(cls.bar)
        cls().func1()


# A.func1()
A.func2()

# compile  把字符串转为字节代码
str1 = '1 * 2 + 3'
c = compile(str1, '', 'eval')
print(eval(c))


# complex

# delattr 删除属性

class coordinate:
    x = 10
    y = 9
    z = 0


point = coordinate()
print('x= {}'.format(point.x))
print('y= {}'.format(point.y))
print('z= {}'.format(point.z))

delattr(coordinate, 'z')
print('x= {}'.format(point.x))
print('y= {}'.format(point.y))
# print('z= {}'.format(point.z)) 出错 z已近被删除


# dict 创建一个字典
a = dict()
b = dict(a='a', b='b', c='c', d='d')
print(a)
print(b)
c = dict([('one', 1), ('two', 2), ('three', 3)])
print(c)
d = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
print(d)

# dir 返回当前函数的 方法
print(dir(a))

# divmod(a,b) 返回商和余数
print(divmod(7, 2))
print(divmod(8, 2))

#enumerate 返回 可遍历的数据对象的下标
str1 = 'test'
print(list(enumerate(str1)))
list1 = ['one','two','three']
print(list(enumerate(list1)))

# eval 执行一个字符串表达式 返回表达式的值
str2 = '1 + 2'
print(eval(str2))

# execfile 执行一个py文件 返回
#execfile('hello.py')

#file 打开文件 返回文件对象

#filter 过滤序列 传过滤函数和可迭代对象

def test_from(n):
    return n % 2 ==0

newfile = filter(test_from, [1,2 ,3, 4,5,6,7,8,9,10])
print(list(newfile))



#float 整数 字符串转化为浮点数
print(float('123.1'))

#format 格式化参数
print('{}  {}'.format('hello', 'fiery'))

# frozenset 生成一个不可变的集合
a = frozenset(range(10))
print(a)

# gettattr 获取对象里面的属性
class A:
    bar = 1
a = A()
print(getattr(a, 'bar'))
print(getattr(a, 'bar2', 3))

#globals 返回当前位置的全局变量
a = 'newfile'
print(globals())

#hasattr 判断是否 对象里面是否含有该 属性
class B:
    x = 10
    y = -5
    z = 8
b = B()
print(hasattr(b , 'x'))
print(hasattr(b , 'y'))
print(hasattr(b , 'b'))

#hash 计算哈希值
print(hash('test'))

#help 显示帮助信息
#help('sys')

#hex 10进制转换为16进制
print(hex(10))
print(hex(1923123))

#id 获取对象的内存地址
print(id(b))

#input 等待输入
#a = input('you name')
#print(a)

#int () 将字符串转化为整形
print(int('123'))
print(int('0x1d5833', 16))

#isinstance 判断一个是不是该类型
abc = 1
print(isinstance(abc, int))
print(isinstance(abc, str))

#issubclass 判断一个类是不是另一个类的子类
class Father:
    pass
class Son(Father):
    pass

print(issubclass(Son, Father))
print(issubclass(Son, A))

#iter 用来生成迭代器
lst = iter([1,2,3,4])
print(next(lst))
print(next(lst))
print(next(lst))

# len() 方法返回对象（字符、列表、元组等）长度或项目个数。
print(len([1,2 ,4,5]))
print(len('fiery'))

#ist() 方法用于将元组转换为列表。
aTuple = (123, 'xyz', 'zara', 'abc')
aList = list(aTuple)

print ("列表元素 : {}".format(aList))

#locals() 函数会以字典类型返回当前位置的全部局部变量。
def runoob(arg):    # 两个局部变量：arg、z
    z = 1
    print (locals())
runoob(4)

#map 循环使用函数 给定列表参数
def add(x):
    print(x + 1)

map(add, [1,2,3])

p = map(lambda x: x ** 2,  [1,2,3,4,5])
print(p)



# max() 方法返回给定参数的最大值，参数可以为序列。
print ("max(80, 100, 1000) : ", max(80, 100, 1000))
print ("max(-20, 100, 400) : ", max(-20, 100, 400))
print ("max(-80, -20, -10) : ", max(-80, -20, -10))
print ("max(0, 100, -400) : ", max(0, 100, -400))


# memoryview() 函数返回给定参数的内存查看对象(Momory view)。
v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1], v[-2])

#min 返回最小值
print ("min(80, 100, 1000) : ", min(80, 100, 1000))
print ("min(-20, 100, 400) : ", min(-20, 100, 400))
print ("min(-80, -20, -10) : ", min(-80, -20, -10))
print ("min(0, 100, -400) : ", min(0, 100, -400))

#oct 整数转化为8进制字符串
print(oct(10))

#open 打开一个文件 返回一个file对象


#pow() 方法返回 xy（x的y次方） 的值。
print ("pow(100, 2) : ", pow(100, 2))

# property 装饰器

#range() 返回一个列表
print(list(range(0, 30, 5)))

#repr() 函数将对象转化为供解释器读取的形式。
dict = {'runoob': 'runoob.com', 'google': 'google.com'};
print(repr(dict))

#reversed 函数返回一个反转的迭代器。
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

#round() 方法返回浮点数x的四舍五入值。
print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))
print ("round(70.23456) : ", round(70.23456))
print ("round(56.659,1) : ", round(56.659,1))
print ("round(80.264, 2) : ", round(80.264, 2))
print ("round(100.000056, 3) : ", round(100.000056, 3))
print ("round(-100.000056, 3) : ", round(-100.000056, 3))

#set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。
x = set('runoob')
y = set('google')
print(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))
print(x & y)
print(x | y)
print(x - y)

#setattr 函数对应函数 getatt()，用于设置属性值，该属性必须存在
class A(object):
    bar = 1

a = A()
print(getattr(a, 'bar'))          # 获取属性 bar 值
setattr(a, 'bar', 5) # 设置属性 bar 值
print(getattr(a, 'bar'))

#slice() 函数实现切片对象，主要用在切片操作函数里的参数传递。
myslice = slice(5)    # 设置截取5个元素的切片
arr = range(10)
print(list(arr))
print(list(arr[myslice]))         # 截取 5 个元素

#sorted() 函数对所有可迭代的对象进行排序操作。
print(sorted([5, 2, 3, 1, 4]))

#sum 求和
print(sum([0,1,2]))

#ars() 函数返回对象object的属性和属性值的字典对象。
x = 1
scope = vars()
print(scope["x"])

# zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组
a = [1, 2, 3]
b = [4, 5, 6]
c = [4, 5, 6, 7, 8]
zipped = zip(a, b)  # 返回一个对象
print(list(zipped))


str2 = '1+2'
print(eval(str2))